import requests
import json
import re
from typing import Optional, Dict, List, Any
from core.config import get_config
from core.logger import get_logger
from tools.utils import clean_markdown_content, validate_markdown_content


class QwenClient:
    """
    Qwen AI客户端类（支持多平台内容生成）
    """

    def __init__(self, model_type: str = 'qwen'):
        """
        初始化Qwen客户端

        Args:
            model_type: 模型类型 ('qwen' 或 'kimi')
        """
        self.config = get_config()
        self.logger = get_logger()
        self.model_type = model_type
        self.qwen_config = self.config.get_qwen_config(model_type)

        # 验证配置
        if not self.qwen_config['api_key']:
            self.logger.error("Qwen API Key未配置")
            raise ValueError("Qwen API Key未配置")

        self.api_key = self.qwen_config['api_key']
        self.base_url = self.qwen_config['base_url']
        self.model = self.qwen_config['model']

        self.logger.info(f"Qwen客户端初始化成功，模型: {self.model}")

    def _make_request(self, messages: list, max_tokens: int = 2000) -> Optional[str]:
        """
        发送请求到Qwen API

        Args:
            messages (list): 消息列表
            max_tokens (int): 最大token数

        Returns:
            Optional[str]: 生成的内容
        """
        try:
            headers = {
                'Authorization': f'Bearer {self.api_key}',
                'Content-Type': 'application/json'
            }

            data = {
                'model': self.model,
                'messages': messages,
                'max_tokens': max_tokens,
                'temperature': 0.7,
                'top_p': 0.9
            }

            self.logger.info(f"发送请求到Qwen API: {self.base_url}/chat/completions")

            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=data,
                timeout=120
            )

            if response.status_code == 200:
                result = response.json()
                if 'choices' in result and len(result['choices']) > 0:
                    content = result['choices'][0]['message']['content']
                    self.logger.info("Qwen API请求成功")
                    return content
                else:
                    self.logger.error(f"Qwen API响应格式错误: {result}")
                    return None
            else:
                self.logger.error(f"Qwen API请求失败: {response.status_code} - {response.text}")
                return None

        except Exception as e:
            self.logger.error(f"Qwen API请求异常: {e}")
            return None

    def analyze_trend(self, hot_item: dict) -> Dict[str, Any]:
        """
        使用Qwen分析热点趋势，返回结构化洞察

        Args:
            hot_item (dict): 热点信息 {title, url, platform}

        Returns:
            dict: 趋势分析结果
        """
        prompt = f"""
请分析以下热点新闻的趋势特征，并以 JSON 格式输出：

【热点信息】
平台：{hot_item.get('platform', '未知')}
标题：{hot_item['title']}
链接：{hot_item['url']}

请输出以下字段的 JSON：
{{
  "topic_category": "科技/AI/社会/娱乐/财经等",
  "hot_level": "1-5分，5为最高",
  "public_emotion": "正面/中性/负面",
  "key_points": ["核心信息点1", "信息点2"],
  "content_angle_suggestions": [
    "适合做技术解读",
    "适合引发争议",
    "适合情感共鸣"
  ],
  "recommended_platforms": ["wechat", "weibo", "short_video", "xiaohongshu", "zhihu"]
}}

只输出纯JSON，不要包含任何解释或```包裹。
"""

        messages = [
            {"role": "system", "content": "你是一个专业的热点趋势分析师，擅长从多维度判断内容传播潜力。"},
            {"role": "user", "content": prompt}
        ]

        try:
            result = self._make_request(messages, max_tokens=500)
            if result:
                cleaned = re.sub(r'^```json\s*|```$', '', result.strip())
                return json.loads(cleaned)
        except Exception as e:
            self.logger.error(f"趋势分析失败: {e}，使用默认值")

        return {
            "topic_category": "综合",
            "hot_level": 3,
            "public_emotion": "中性",
            "key_points": [hot_item['title']],
            "content_angle_suggestions": ["简要解读"],
            "recommended_platforms": ["wechat", "weibo"]
        }

    def generate_platform_specific_title(self, item: dict, platform: str, insight: dict) -> str:
        """
        为指定平台生成专属爆款标题

        Args:
            item (dict): 原始热点
            platform (str): 平台名称
            insight (dict): 趋势分析结果

        Returns:
            str: 生成的标题
        """
        platform_styles = {
            'wechat': '微信公众号风格：深度、启发性，如“深度揭秘：XXX背后真相”',
            'weibo': '微博风格：短、爆、话题感，如“突发！XXX震惊全网”',
            'short_video': '短视频风格：钩子强、情绪浓，如“99%人不知道的XXX”',
            'xiaohongshu': '小红书风格：亲切、种草感，如“姐妹们！XXX真的绝了”',
            'zhihu': '知乎风格：理性、观点感，如“如何评价XXX？这可能是最全解读”'
        }

        style = platform_styles.get(platform, "适合该平台传播的风格")

        prompt = f"""
请为以下热点生成一个适合 {platform} 平台的爆款标题：

热点标题：{item['title']}
趋势洞察：{insight.get('content_angle_suggestions', ['亮点解读'])[0]}
平台风格：{style}

要求：
- 10-30字
- 有吸引力，激发点击
- 符合平台调性
- 可使用数字、疑问、感叹
- 避免标题党

只输出标题，不要解释。
"""

        messages = [
            {"role": "system", "content": "你是一位资深新媒体运营，精通各平台爆款标题创作。"},
            {"role": "user", "content": prompt}
        ]

        try:
            result = self._make_request(messages, max_tokens=100)
            if result:
                return result.strip().strip('"').strip("'").strip()
        except Exception as e:
            self.logger.error(f"生成 {platform} 标题失败: {e}")

        # 失败则返回原标题
        return item['title']

    def generate_multi_platform_content(
            self,
            hot_item: dict,
            platform: str = None,
            use_trend_analysis: bool = True
    ) -> Dict[str, Dict[str, str]]:
        """
        为多个平台生成内容：先生成专属标题，再生成内容

        Args:
            hot_item (dict): 热点信息 {title, url, platform}
            platform (list): 热点所处平台
            use_trend_analysis (bool): 是否启用趋势分析

        Returns:
            dict: {平台: {title: 标题, content: 内容}}
        """
        if platform is None:
            platform = 'wechat'

        self.logger.info(f"原始热点: {hot_item['title']}")

        # 1. 趋势分析
        trend_insight = {}
        if use_trend_analysis:
            trend_insight = self.analyze_trend(hot_item)
            self.logger.info(f"趋势分析完成: {trend_insight['topic_category']} | 热度{trend_insight['hot_level']}")

        results = {}

        # 2. 为每个平台：先生成标题，再生成内容
        if trend_insight['recommended_platforms'] is None:
            try:
                # 生成专属标题
                title = self.generate_platform_specific_title(hot_item, platform, trend_insight)
                self.logger.info(f"{platform} 爆款标题生成: {title}")

                # 生成内容（使用新标题）
                if hasattr(self, f'_generate_for_{platform}'):
                    content_data = getattr(self, f'_generate_for_{platform}')(hot_item, trend_insight)
                    # 强制使用新标题
                    content_data['title'] = title
                    results[platform] = content_data
                    self.logger.info(f"{platform} 内容生成成功")
                else:
                    self.logger.warning(f"未实现 {platform} 的生成逻辑")
                    results[platform] = {"title": title, "content": "该平台生成逻辑未实现"}

            except Exception as e:
                self.logger.error(f"生成 {platform} 内容失败: {e}")
                results[platform] = {"title": hot_item['title'], "content": "内容生成失败"}

            return results
        else:
            self.logger.info(f"开始为{len(trend_insight['recommended_platforms'])}个平台生成内容")
            for platform in trend_insight['recommended_platforms']:
                try:
                    # 生成专属标题
                    title = self.generate_platform_specific_title(hot_item, platform, trend_insight)
                    self.logger.info(f"{platform} 爆款标题生成: {title}")

                    # 生成内容（使用新标题）
                    method_name = platform.replace('-', '_')
                    if hasattr(self, f'_generate_for_{method_name}'):
                        content_data = getattr(self, f'_generate_for_{method_name}')(hot_item, trend_insight)
                        # 强制使用新标题
                        content_data['title'] = title
                        results[method_name] = content_data
                        self.logger.info(f"{method_name} 内容生成成功")
                    else:
                        self.logger.warning(f"未实现 {method_name} 的生成逻辑")
                        results[method_name] = {"title": title, "content": "该平台生成逻辑未实现"}

                except Exception as e:
                    self.logger.error(f"生成 {method_name} 内容失败: {e}")
                    results[method_name] = {"title": hot_item['title'], "content": "内容生成失败"}

            return results

    def _generate_for_wechat(self, item: dict, insight: dict) -> Dict[str, str]:
        """公众号：深度解读文章"""
        prompt = f"""
请根据以下标题创作一篇微信公众号深度文章：

标题：{item['title']}
【趋势洞察】{insight.get('content_angle_suggestions', ['简要解读'])[0]}

要求：
- 字数1500-2500，结构清晰（引言/背景/分析/结尾）
- 语言通俗但有深度，避免术语堆砌
- 使用 ## 小标题 和 - 列表 增强可读性
- 结尾有启发性或总结
- 不要使用“本文”“笔者认为”等主观表述
- 使用正常口语化表达，去除AI味

直接输出文章内容（包含标题），不要包含任何解释。
"""

        messages = [
            {"role": "system", "content": "你是资深公众号主编，擅长写深度解读文章。"},
            {"role": "user", "content": prompt}
        ]
        content = self._make_request(messages, max_tokens=3000)
        if content:
            cleaned = clean_markdown_content(content)
            first_line = cleaned.strip().split('\n')[0].strip('# ').strip()
            return {"title": first_line, "content": cleaned}
        return {"title": item['title'], "content": content or ""}

    def _generate_for_weibo(self, item: dict, insight: dict) -> Dict[str, str]:
        """微博：短评 + 互动"""
        prompt = f"""
请为微博平台撰写一条短评：

热点：{item['title']}
情绪：{insight.get('public_emotion', '中性')}

要求：
- ≤500字
- 开头用“突发！”“刚刚！”“重磅！”等吸引眼球
- 使用1-2个话题标签，如 #AI大模型#
- 可@相关账号（如 @官方）
- 结尾提出问题引发讨论
- 语言简洁有力，适合转发

只输出内容，不要解释。
"""
        messages = [
            {"role": "system", "content": "你是微博热门博主，擅长制造话题和引发讨论。"},
            {"role": "user", "content": prompt}
        ]
        content = self._make_request(messages, max_tokens=500)
        return {"title": item['title'], "content": content or ""}

    def _generate_for_short_video(self, item: dict, insight: dict) -> Dict[str, str]:
        """短视频：口播脚本"""
        prompt = f"""
生成一个60秒内的抖音/快手口播脚本：

热点：{item['title']}
角度：{insight.get('content_angle_suggestions', ['亮点解读'])[0]}

格式：
[0-5s] 开场钩子（疑问/震惊）
[5-20s] 核心信息
[20-45s] 深度解读
[45-60s] 结尾互动

要求：
- 语言口语化，多用“你”“我们”“真的绝了”
- 可加入音效建议，如 [音效：叮]
- 避免AI腔调

只输出脚本内容。
"""
        messages = [
            {"role": "system", "content": "你是短视频爆款脚本专家。"},
            {"role": "user", "content": prompt}
        ]
        content = self._make_request(messages, max_tokens=800)
        return {"title": item['title'], "content": content or ""}

    def _generate_for_xiaohongshu(self, item: dict, insight: dict) -> Dict[str, str]:
        """小红书：轻松图文笔记"""
        prompt = f"""
写一篇小红书风格的图文笔记：

标题灵感：{item['title']}
风格：女生口吻，用“姐妹们！”“谁懂啊”“真的惊到我了”“不看后悔”

要求：
- 轻松活泼，带 emoji 💥🔥✨
- 每段不要太长，适当换行
- 加3-5个话题，如 #科技好物 #AI神器
- 结尾引导“赶紧码住！”“收藏不亏”

只输出内容。
"""
        messages = [
            {"role": "system", "content": "你是小红书百万粉丝博主。"},
            {"role": "user", "content": prompt}
        ]
        content = self._make_request(messages, max_tokens=600)
        return {"title": item['title'], "content": content or ""}

    def _generate_for_zhihu(self, item: dict, insight: dict) -> Dict[str, str]:
        """知乎：观点型回答"""
        prompt = f"""
请以专业视角回答：“{item['title']} 说明了什么趋势？”

【趋势洞察】{json.dumps(insight, ensure_ascii=False)}

要求：
- 观点先行 → 数据/事实支撑 → 行业对比 → 未来展望
- 引用权威数据或历史事件增强可信度
- 语言理性克制，避免情绪化
- 结尾提出开放性问题
- 不要使用“我认为”，用“可以观察到”“数据显示”

只输出回答内容。
"""
        messages = [
            {"role": "system", "content": "你是知乎科技领域优秀答主。"},
            {"role": "user", "content": prompt}
        ]
        content = self._make_request(messages, max_tokens=2000)
        return {"title": item['title'], "content": content or ""}

    def test_connection(self) -> bool:
        """
        测试与Qwen API的连接
        """
        try:
            messages = [
                {"role": "user", "content": "Hello"}
            ]
            response = self._make_request(messages, max_tokens=10)
            if response is not None:
                self.logger.info("Qwen API连接测试成功")
                return True
            else:
                self.logger.error("Qwen API连接测试失败: 无法获取响应")
                return False
        except Exception as e:
            self.logger.error(f"Qwen API连接测试异常: {e}")
            return False




    def generate_article_from_content(self, content: str) -> tuple[Optional[str], Optional[str]]:
        """
        根据多文字内容生成文章

        Args:
            content (str): 输入的多文字内容

        Returns:
            tuple[Optional[str], Optional[str]]: (文章内容, 生成的标题)
        """
        try:
            self.logger.info(f"开始使用Qwen根据多文字内容生成文章")

            # 1. 先生成一个合适的标题
            title_prompt = f"""
    请根据下面的内容提要，生成一个吸引人的文章标题：
    
    标题围绕这个内容进行生成:
    {content}
    
    要求：
    1. 标题要简洁明了，能概括主要内容
    2. 长度控制在15-35个字之间
    3. 要有吸引力，能激发读者兴趣
    4. 符合微信公众号文章标题的特点
    5. 可以使用疑问句、反问句等形式
    
    请只输出一个最佳的标题，不要包含任何解释或说明。
    """

            title_messages = [
                {
                    "role": "system",
                    "content": "你是一位专业的内容创作者，擅长创作吸引人的文章标题。"
                },
                {
                    "role": "user",
                    "content": title_prompt
                }
            ]

            # 生成标题
            generated_title = self._make_request(title_messages, max_tokens=100)
            if not generated_title:
                self.logger.error("标题生成失败")
                return None, None

            # 清理标题
            final_title = generated_title.strip().strip('"').strip("'")
            self.logger.info(f"生成的标题: {final_title}")

            # 2. 生成文章内容
            article_prompt = f"""
    请根据下面的内容提要和标题，创作一篇高质量的微信公众号文章：
    
    标题：{final_title}
    
    生成的文章内容必须围绕这个主题进行：
    {content}
    
    要求：
    1. 文章结构清晰，包含引言、正文和结尾
    2. 内容要有深度，有见解，有价值
    3. 语言生动有趣，适合微信公众号阅读
    4. 字数控制在1500-2500字之间
    5. 使用Markdown格式输出
    6. 包含适当的小标题和段落分隔
    7. 结尾要有启发性或总结性
    8. 避免过于商业化的内容
    9. 文章内容要围绕着提供的内容提要展开，保持主题一致性
    
    特别注意：文章内容的文字一定要使用正常的一般性口语，不要用特别的专业性疗于。而且一定要去除AI味的痕迹。
    
    请直接输出文章内容，不要包含任何解释或说明文字。
    """

            article_messages = [
                {
                    "role": "system",
                    "content": "你是一位专业的内容创作者，擅长写作高质量的微信公众号文章。你的文章总是能够吸引读者，内容有深度且易于理解。"
                },
                {
                    "role": "user",
                    "content": article_prompt
                }
            ]

            # 3. 发送请求生成文章
            article_content = self._make_request(article_messages, max_tokens=3000)

            if article_content:
                # 清理AI生成的Markdown内容中的多余字符
                cleaned_content = clean_markdown_content(article_content)

                # 验证清理后的内容
                if validate_markdown_content(cleaned_content):
                    self.logger.info(f"文章生成成功（多文字内容），内容已清理: {final_title}")
                    return cleaned_content, final_title
                else:
                    self.logger.warning(f"内容清理后验证失败，使用原始内容: {final_title}")
                    return article_content, final_title
            else:
                self.logger.error(f"文章生成失败（多文字内容）: {final_title}")
                return None, None

        except Exception as e:
            self.logger.error(f"根据多文字内容生成文章时发生错误: {e}")
            return None, None

# 全局实例
_qwen_client = None
_kimi_client = None


def get_qwen_client(model_type: str = 'qwen') -> QwenClient:
    """
    获取全局Qwen客户端实例
    """
    global _qwen_client, _kimi_client

    if model_type == 'kimi':
        if _kimi_client is None:
            _kimi_client = QwenClient('kimi')
        return _kimi_client
    else:
        if _qwen_client is None:
            _qwen_client = QwenClient('qwen')
        return _qwen_client
